home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / lib / mntlib44.zoo / mntlib / purec / bcopy.s < prev    next >
Text File  |  1993-05-23  |  4KB  |  201 lines
  1. ; ***** VERSION ONLY FOR TURBO/PUREC *****
  2. ;    new version of bcopy, memcpy and memmove
  3. ;    handles overlap, odd/even alignment
  4. ;    uses movem to copy 256 bytes blocks faster.
  5. ;    Alexander Lehmann    alexlehm@iti.informatik.th-darmstadt.de
  6. ;    sortof inspired by jrbs bcopy
  7.  
  8.     .text
  9.     .even
  10.     .globl    bcopy,_bcopy
  11.     .globl    memcpy
  12.     .globl    memmove
  13.  
  14. ;    void *memcpy( void *dest, const void *src, size_t len );
  15. ;    void *memmove( void *dest, const void *src, size_t len );
  16. ;    returns dest
  17. ;    functions are aliased
  18.  
  19. memcpy:
  20. memmove:
  21.     exg    a0,a1        ; dest <-> src
  22.  
  23. ;    void bcopy( const void *src, void *dest, size_t length );
  24. ;    return value not used (returns dest)
  25.  
  26. _bcopy:
  27. bcopy:
  28.     pea    (a1)        ; push dest
  29.     tst.l    d0        ; length
  30.     beq    exit        ; length==0? (size_t)
  31.  
  32.                 ; a0 src, a1 dest, d0.l length
  33.     ; overlay ?
  34.     cmp.l    a0,a1
  35.     bgt    top_down
  36.  
  37.     move.w    a0,d1        ; test for alignment
  38.     move.w    a1,d2
  39.     eor.w    d2,d1
  40.     btst    #0,d1        ; one odd one even ?
  41.     bne    slow_copy
  42.     btst    #0,d2        ; both even ?
  43.     beq.b    both_even
  44.     move.b    (a0)+,(a1)+    ; copy one byte, now we are both even
  45.     subq.l    #1,d0
  46. both_even:
  47.     move.b    d0,d1        ; save length less 256
  48.     lsr.l    #8,d0        ; number of 256 bytes blocks
  49.     beq.b    less256
  50.     movem.l    d1/d3-d7/a2-a6,-(sp)    ; d2 is scratch reg
  51. copy256:
  52.     movem.l    (a0)+,d1-d7/a2-a6    ; copy 5*48+16=256 bytes
  53.     movem.l    d1-d7/a2-a6,(a1)
  54.     movem.l    (a0)+,d1-d7/a2-a6
  55.     movem.l    d1-d7/a2-a6,48(a1)
  56.     movem.l    (a0)+,d1-d7/a2-a6
  57.     movem.l    d1-d7/a2-a6,96(a1)
  58.     movem.l    (a0)+,d1-d7/a2-a6
  59.     movem.l    d1-d7/a2-a6,144(a1)
  60.     movem.l    (a0)+,d1-d7/a2-a6
  61.     movem.l    d1-d7/a2-a6,192(a1)
  62.     movem.l    (a0)+,d1-d4
  63.     movem.l    d1-d4,240(a1)
  64.     lea    256(a1),a1        ; increment dest, src is already
  65.     subq.l    #1,d0
  66.     bne.b    copy256         ; next, please
  67.     movem.l    (sp)+,d1/d3-d7/a2-a6
  68. less256:            ; copy 16 bytes blocks
  69.     move.b    d1,d0        ; d0.w always 0
  70.     lsr.b    #2,d0        ; number of 4 bytes blocks
  71.     beq.b    less4        ; less that 4 bytes left
  72.     move.w    d0,d2
  73.     subq.b    #1,d0
  74.     lsr.b    #2,d0        ; number of 16 bytes blocks minus 1, if d2==0
  75.     neg.w    d2
  76.     and.w    #3,d2        ; d2 = number of bytes below 16 (-n)&3
  77.     add.w    d2,d2        ; offset in code (movl two bytes)
  78.     jmp    2(pc,d2.w)    ; jmp into loop
  79. copy16:
  80.     move.l    (a0)+,(a1)+
  81.     move.l    (a0)+,(a1)+
  82.     move.l    (a0)+,(a1)+
  83.     move.l    (a0)+,(a1)+
  84.     dbra    d0,copy16
  85. less4:
  86.     btst    #1,d1
  87.     beq.b    less2
  88.     move.w    (a0)+,(a1)+
  89. less2:
  90.     btst    #0,d1
  91.     beq.b    exit
  92.     move.b    (a0),(a1)
  93. exit:
  94.     move.l (sp)+,a0        ; return dest (for memcpy only)
  95.     rts
  96.  
  97. slow_copy:            ; byte by bytes copy
  98.     move.w    d0,d1
  99.     neg.w    d1
  100.     and.w    #7,d1        ; d1 = number of bytes blow 8 (-n)&7
  101.     addq.l    #7,d0
  102.     lsr.l    #3,d0        ; number of 8 bytes block plus 1, if d1!=0
  103.     add.w    d1,d1        ; offset in code (movb two bytes)
  104.     jmp    2(pc,d1.w)    ; jump into loop
  105. scopy:
  106.     move.b    (a0)+,(a1)+
  107.     move.b    (a0)+,(a1)+
  108.     move.b    (a0)+,(a1)+
  109.     move.b    (a0)+,(a1)+
  110.     move.b    (a0)+,(a1)+
  111.     move.b    (a0)+,(a1)+
  112.     move.b    (a0)+,(a1)+
  113.     move.b    (a0)+,(a1)+
  114.     subq.l    #1,d0
  115.     bne.b    scopy
  116.     bra.b    exit
  117.  
  118. top_down:
  119.     add.l    d0,a0        ; a0 byte after end of src
  120.     add.l    d0,a1        ; a1 byte after end of dest
  121.  
  122.     move.w    a0,d1        ; exact the same as above, only with predec
  123.     move.w    a1,d2
  124.     eor.w    d2,d1
  125.     btst    #0,d1
  126.     bne    slow_copy_d
  127.  
  128.     btst    #0,d2
  129.     beq.b    both_even_d
  130.     move.b    -(a0),-(a1)
  131.     subq.l    #1,d0
  132. both_even_d:
  133.     move.b    d0,d1
  134.     lsr.l    #8,d0
  135.     beq.b    less256_d
  136.     movem.l    d1/d3-d7/a2-a6,-(sp)    ; d2 is scratch reg
  137. copy256_d:
  138.     movem.l    -48(a0),d1-d7/a2-a6    ; copy 5*48+16=256 bytes
  139.     movem.l    d1-d7/a2-a6,-(a1)
  140.     movem.l    -96(a0),d1-d7/a2-a6
  141.     movem.l    d1-d7/a2-a6,-(a1)
  142.     movem.l    -144(a0),d1-d7/a2-a6
  143.     movem.l    d1-d7/a2-a6,-(a1)
  144.     movem.l    -192(a0),d1-d7/a2-a6
  145.     movem.l    d1-d7/a2-a6,-(a1)
  146.     movem.l    -240(a0),d1-d7/a2-a6
  147.     movem.l    d1-d7/a2-a6,-(a1)
  148.     movem.l    -256(a0),d1-d4
  149.     movem.l    d1-d4,-(a1)
  150.     lea    -256(a0),a0
  151.     subq.l    #1,d0
  152.     bne.b    copy256_d
  153.     movem.l    (sp)+,d1/d3-d7/a2-a6
  154. less256_d:
  155.     move.b    d1,d0
  156.     lsr.b    #2,d0
  157.     beq.b    less4_d
  158.     move.w    d0,d2
  159.     subq.b    #1,d0
  160.     lsr.b    #2,d0
  161.     neg.w    d2
  162.     and.w    #3,d2
  163.     add.w    d2,d2
  164.     jmp    2(pc,d2.w)
  165. copy16_d:
  166.     move.l    -(a0),-(a1)
  167.     move.l    -(a0),-(a1)
  168.     move.l    -(a0),-(a1)
  169.     move.l    -(a0),-(a1)
  170.     dbra    d0,copy16_d
  171. less4_d:
  172.     btst    #1,d1
  173.     beq.b    less2_d
  174.     move.w    -(a0),-(a1)
  175. less2_d:
  176.     btst    #0,d1
  177.     beq    exit
  178.     move.b    -(a0),-(a1)
  179.     bra    exit
  180. slow_copy_d:
  181.     move.w    d0,d1
  182.     neg.w    d1
  183.     and.w    #7,d1
  184.     addq.l    #7,d0
  185.     lsr.l    #3,d0
  186.     add.w    d1,d1
  187.     jmp    2(pc,d1.w)
  188. scopy_d:
  189.     move.b    -(a0),-(a1)
  190.     move.b    -(a0),-(a1)
  191.     move.b    -(a0),-(a1)
  192.     move.b    -(a0),-(a1)
  193.     move.b    -(a0),-(a1)
  194.     move.b    -(a0),-(a1)
  195.     move.b    -(a0),-(a1)
  196.     move.b    -(a0),-(a1)
  197.     subq.l    #1,d0
  198.     bne.b    scopy_d
  199.     bra    exit
  200.  
  201.